core/iter/traits/collect.rs
1use super::TrustedLen;
2
3/// Conversion from an [`Iterator`].
4///
5/// By implementing `FromIterator` for a type, you define how it will be
6/// created from an iterator. This is common for types which describe a
7/// collection of some kind.
8///
9/// If you want to create a collection from the contents of an iterator, the
10/// [`Iterator::collect()`] method is preferred. However, when you need to
11/// specify the container type, [`FromIterator::from_iter()`] can be more
12/// readable than using a turbofish (e.g. `::<Vec<_>>()`). See the
13/// [`Iterator::collect()`] documentation for more examples of its use.
14///
15/// See also: [`IntoIterator`].
16///
17/// # Examples
18///
19/// Basic usage:
20///
21/// ```
22/// let five_fives = std::iter::repeat(5).take(5);
23///
24/// let v = Vec::from_iter(five_fives);
25///
26/// assert_eq!(v, vec![5, 5, 5, 5, 5]);
27/// ```
28///
29/// Using [`Iterator::collect()`] to implicitly use `FromIterator`:
30///
31/// ```
32/// let five_fives = std::iter::repeat(5).take(5);
33///
34/// let v: Vec<i32> = five_fives.collect();
35///
36/// assert_eq!(v, vec![5, 5, 5, 5, 5]);
37/// ```
38///
39/// Using [`FromIterator::from_iter()`] as a more readable alternative to
40/// [`Iterator::collect()`]:
41///
42/// ```
43/// use std::collections::VecDeque;
44/// let first = (0..10).collect::<VecDeque<i32>>();
45/// let second = VecDeque::from_iter(0..10);
46///
47/// assert_eq!(first, second);
48/// ```
49///
50/// Implementing `FromIterator` for your type:
51///
52/// ```
53/// // A sample collection, that's just a wrapper over Vec<T>
54/// #[derive(Debug)]
55/// struct MyCollection(Vec<i32>);
56///
57/// // Let's give it some methods so we can create one and add things
58/// // to it.
59/// impl MyCollection {
60/// fn new() -> MyCollection {
61/// MyCollection(Vec::new())
62/// }
63///
64/// fn add(&mut self, elem: i32) {
65/// self.0.push(elem);
66/// }
67/// }
68///
69/// // and we'll implement FromIterator
70/// impl FromIterator<i32> for MyCollection {
71/// fn from_iter<I: IntoIterator<Item=i32>>(iter: I) -> Self {
72/// let mut c = MyCollection::new();
73///
74/// for i in iter {
75/// c.add(i);
76/// }
77///
78/// c
79/// }
80/// }
81///
82/// // Now we can make a new iterator...
83/// let iter = (0..5).into_iter();
84///
85/// // ... and make a MyCollection out of it
86/// let c = MyCollection::from_iter(iter);
87///
88/// assert_eq!(c.0, vec![0, 1, 2, 3, 4]);
89///
90/// // collect works too!
91///
92/// let iter = (0..5).into_iter();
93/// let c: MyCollection = iter.collect();
94///
95/// assert_eq!(c.0, vec![0, 1, 2, 3, 4]);
96/// ```
97#[stable(feature = "rust1", since = "1.0.0")]
98#[rustc_on_unimplemented(
99 on(
100 Self = "&[{A}]",
101 message = "a slice of type `{Self}` cannot be built since we need to store the elements somewhere",
102 label = "try explicitly collecting into a `Vec<{A}>`",
103 ),
104 on(
105 all(A = "{integer}", any(Self = "&[{integral}]",)),
106 message = "a slice of type `{Self}` cannot be built since we need to store the elements somewhere",
107 label = "try explicitly collecting into a `Vec<{A}>`",
108 ),
109 on(
110 Self = "[{A}]",
111 message = "a slice of type `{Self}` cannot be built since `{Self}` has no definite size",
112 label = "try explicitly collecting into a `Vec<{A}>`",
113 ),
114 on(
115 all(A = "{integer}", any(Self = "[{integral}]",)),
116 message = "a slice of type `{Self}` cannot be built since `{Self}` has no definite size",
117 label = "try explicitly collecting into a `Vec<{A}>`",
118 ),
119 on(
120 Self = "[{A}; _]",
121 message = "an array of type `{Self}` cannot be built directly from an iterator",
122 label = "try collecting into a `Vec<{A}>`, then using `.try_into()`",
123 ),
124 on(
125 all(A = "{integer}", any(Self = "[{integral}; _]",)),
126 message = "an array of type `{Self}` cannot be built directly from an iterator",
127 label = "try collecting into a `Vec<{A}>`, then using `.try_into()`",
128 ),
129 message = "a value of type `{Self}` cannot be built from an iterator \
130 over elements of type `{A}`",
131 label = "value of type `{Self}` cannot be built from `std::iter::Iterator<Item={A}>`"
132)]
133#[rustc_diagnostic_item = "FromIterator"]
134pub trait FromIterator<A>: Sized {
135 /// Creates a value from an iterator.
136 ///
137 /// See the [module-level documentation] for more.
138 ///
139 /// [module-level documentation]: crate::iter
140 ///
141 /// # Examples
142 ///
143 /// ```
144 /// let five_fives = std::iter::repeat(5).take(5);
145 ///
146 /// let v = Vec::from_iter(five_fives);
147 ///
148 /// assert_eq!(v, vec![5, 5, 5, 5, 5]);
149 /// ```
150 #[stable(feature = "rust1", since = "1.0.0")]
151 #[rustc_diagnostic_item = "from_iter_fn"]
152 fn from_iter<T: IntoIterator<Item = A>>(iter: T) -> Self;
153}
154
155/// Conversion into an [`Iterator`].
156///
157/// By implementing `IntoIterator` for a type, you define how it will be
158/// converted to an iterator. This is common for types which describe a
159/// collection of some kind.
160///
161/// One benefit of implementing `IntoIterator` is that your type will [work
162/// with Rust's `for` loop syntax](crate::iter#for-loops-and-intoiterator).
163///
164/// See also: [`FromIterator`].
165///
166/// # Examples
167///
168/// Basic usage:
169///
170/// ```
171/// let v = [1, 2, 3];
172/// let mut iter = v.into_iter();
173///
174/// assert_eq!(Some(1), iter.next());
175/// assert_eq!(Some(2), iter.next());
176/// assert_eq!(Some(3), iter.next());
177/// assert_eq!(None, iter.next());
178/// ```
179/// Implementing `IntoIterator` for your type:
180///
181/// ```
182/// // A sample collection, that's just a wrapper over Vec<T>
183/// #[derive(Debug)]
184/// struct MyCollection(Vec<i32>);
185///
186/// // Let's give it some methods so we can create one and add things
187/// // to it.
188/// impl MyCollection {
189/// fn new() -> MyCollection {
190/// MyCollection(Vec::new())
191/// }
192///
193/// fn add(&mut self, elem: i32) {
194/// self.0.push(elem);
195/// }
196/// }
197///
198/// // and we'll implement IntoIterator
199/// impl IntoIterator for MyCollection {
200/// type Item = i32;
201/// type IntoIter = std::vec::IntoIter<Self::Item>;
202///
203/// fn into_iter(self) -> Self::IntoIter {
204/// self.0.into_iter()
205/// }
206/// }
207///
208/// // Now we can make a new collection...
209/// let mut c = MyCollection::new();
210///
211/// // ... add some stuff to it ...
212/// c.add(0);
213/// c.add(1);
214/// c.add(2);
215///
216/// // ... and then turn it into an Iterator:
217/// for (i, n) in c.into_iter().enumerate() {
218/// assert_eq!(i as i32, n);
219/// }
220/// ```
221///
222/// It is common to use `IntoIterator` as a trait bound. This allows
223/// the input collection type to change, so long as it is still an
224/// iterator. Additional bounds can be specified by restricting on
225/// `Item`:
226///
227/// ```rust
228/// fn collect_as_strings<T>(collection: T) -> Vec<String>
229/// where
230/// T: IntoIterator,
231/// T::Item: std::fmt::Debug,
232/// {
233/// collection
234/// .into_iter()
235/// .map(|item| format!("{item:?}"))
236/// .collect()
237/// }
238/// ```
239#[rustc_diagnostic_item = "IntoIterator"]
240#[rustc_on_unimplemented(
241 on(
242 Self = "core::ops::range::RangeTo<Idx>",
243 label = "if you meant to iterate until a value, add a starting value",
244 note = "`..end` is a `RangeTo`, which cannot be iterated on; you might have meant to have a \
245 bounded `Range`: `0..end`"
246 ),
247 on(
248 Self = "core::ops::range::RangeToInclusive<Idx>",
249 label = "if you meant to iterate until a value (including it), add a starting value",
250 note = "`..=end` is a `RangeToInclusive`, which cannot be iterated on; you might have meant \
251 to have a bounded `RangeInclusive`: `0..=end`"
252 ),
253 on(
254 Self = "[]",
255 label = "`{Self}` is not an iterator; try calling `.into_iter()` or `.iter()`"
256 ),
257 on(Self = "&[]", label = "`{Self}` is not an iterator; try calling `.iter()`"),
258 on(
259 Self = "alloc::vec::Vec<T, A>",
260 label = "`{Self}` is not an iterator; try calling `.into_iter()` or `.iter()`"
261 ),
262 on(Self = "&str", label = "`{Self}` is not an iterator; try calling `.chars()` or `.bytes()`"),
263 on(
264 Self = "alloc::string::String",
265 label = "`{Self}` is not an iterator; try calling `.chars()` or `.bytes()`"
266 ),
267 on(
268 Self = "{integral}",
269 note = "if you want to iterate between `start` until a value `end`, use the exclusive range \
270 syntax `start..end` or the inclusive range syntax `start..=end`"
271 ),
272 on(
273 Self = "{float}",
274 note = "if you want to iterate between `start` until a value `end`, use the exclusive range \
275 syntax `start..end` or the inclusive range syntax `start..=end`"
276 ),
277 label = "`{Self}` is not an iterator",
278 message = "`{Self}` is not an iterator"
279)]
280#[rustc_skip_during_method_dispatch(array, boxed_slice)]
281#[stable(feature = "rust1", since = "1.0.0")]
282pub trait IntoIterator {
283 /// The type of the elements being iterated over.
284 #[rustc_diagnostic_item = "IntoIteratorItem"]
285 #[stable(feature = "rust1", since = "1.0.0")]
286 type Item;
287
288 /// Which kind of iterator are we turning this into?
289 #[stable(feature = "rust1", since = "1.0.0")]
290 type IntoIter: Iterator<Item = Self::Item>;
291
292 /// Creates an iterator from a value.
293 ///
294 /// See the [module-level documentation] for more.
295 ///
296 /// [module-level documentation]: crate::iter
297 ///
298 /// # Examples
299 ///
300 /// ```
301 /// let v = [1, 2, 3];
302 /// let mut iter = v.into_iter();
303 ///
304 /// assert_eq!(Some(1), iter.next());
305 /// assert_eq!(Some(2), iter.next());
306 /// assert_eq!(Some(3), iter.next());
307 /// assert_eq!(None, iter.next());
308 /// ```
309 #[lang = "into_iter"]
310 #[stable(feature = "rust1", since = "1.0.0")]
311 fn into_iter(self) -> Self::IntoIter;
312}
313
314#[stable(feature = "rust1", since = "1.0.0")]
315impl<I: Iterator> IntoIterator for I {
316 type Item = I::Item;
317 type IntoIter = I;
318
319 #[inline]
320 fn into_iter(self) -> I {
321 self
322 }
323}
324
325/// Extend a collection with the contents of an iterator.
326///
327/// Iterators produce a series of values, and collections can also be thought
328/// of as a series of values. The `Extend` trait bridges this gap, allowing you
329/// to extend a collection by including the contents of that iterator. When
330/// extending a collection with an already existing key, that entry is updated
331/// or, in the case of collections that permit multiple entries with equal
332/// keys, that entry is inserted.
333///
334/// # Examples
335///
336/// Basic usage:
337///
338/// ```
339/// // You can extend a String with some chars:
340/// let mut message = String::from("The first three letters are: ");
341///
342/// message.extend(&['a', 'b', 'c']);
343///
344/// assert_eq!("abc", &message[29..32]);
345/// ```
346///
347/// Implementing `Extend`:
348///
349/// ```
350/// // A sample collection, that's just a wrapper over Vec<T>
351/// #[derive(Debug)]
352/// struct MyCollection(Vec<i32>);
353///
354/// // Let's give it some methods so we can create one and add things
355/// // to it.
356/// impl MyCollection {
357/// fn new() -> MyCollection {
358/// MyCollection(Vec::new())
359/// }
360///
361/// fn add(&mut self, elem: i32) {
362/// self.0.push(elem);
363/// }
364/// }
365///
366/// // since MyCollection has a list of i32s, we implement Extend for i32
367/// impl Extend<i32> for MyCollection {
368///
369/// // This is a bit simpler with the concrete type signature: we can call
370/// // extend on anything which can be turned into an Iterator which gives
371/// // us i32s. Because we need i32s to put into MyCollection.
372/// fn extend<T: IntoIterator<Item=i32>>(&mut self, iter: T) {
373///
374/// // The implementation is very straightforward: loop through the
375/// // iterator, and add() each element to ourselves.
376/// for elem in iter {
377/// self.add(elem);
378/// }
379/// }
380/// }
381///
382/// let mut c = MyCollection::new();
383///
384/// c.add(5);
385/// c.add(6);
386/// c.add(7);
387///
388/// // let's extend our collection with three more numbers
389/// c.extend(vec![1, 2, 3]);
390///
391/// // we've added these elements onto the end
392/// assert_eq!("MyCollection([5, 6, 7, 1, 2, 3])", format!("{c:?}"));
393/// ```
394#[stable(feature = "rust1", since = "1.0.0")]
395pub trait Extend<A> {
396 /// Extends a collection with the contents of an iterator.
397 ///
398 /// As this is the only required method for this trait, the [trait-level] docs
399 /// contain more details.
400 ///
401 /// [trait-level]: Extend
402 ///
403 /// # Examples
404 ///
405 /// ```
406 /// // You can extend a String with some chars:
407 /// let mut message = String::from("abc");
408 ///
409 /// message.extend(['d', 'e', 'f'].iter());
410 ///
411 /// assert_eq!("abcdef", &message);
412 /// ```
413 #[stable(feature = "rust1", since = "1.0.0")]
414 fn extend<T: IntoIterator<Item = A>>(&mut self, iter: T);
415
416 /// Extends a collection with exactly one element.
417 #[unstable(feature = "extend_one", issue = "72631")]
418 fn extend_one(&mut self, item: A) {
419 self.extend(Some(item));
420 }
421
422 /// Reserves capacity in a collection for the given number of additional elements.
423 ///
424 /// The default implementation does nothing.
425 #[unstable(feature = "extend_one", issue = "72631")]
426 fn extend_reserve(&mut self, additional: usize) {
427 let _ = additional;
428 }
429
430 /// Extends a collection with one element, without checking there is enough capacity for it.
431 ///
432 /// # Safety
433 ///
434 /// **For callers:** This must only be called when we know the collection has enough capacity
435 /// to contain the new item, for example because we previously called `extend_reserve`.
436 ///
437 /// **For implementors:** For a collection to unsafely rely on this method's safety precondition (that is,
438 /// invoke UB if they are violated), it must implement `extend_reserve` correctly. In other words,
439 /// callers may assume that if they `extend_reserve`ed enough space they can call this method.
440 // This method is for internal usage only. It is only on the trait because of specialization's limitations.
441 #[unstable(feature = "extend_one_unchecked", issue = "none")]
442 #[doc(hidden)]
443 unsafe fn extend_one_unchecked(&mut self, item: A)
444 where
445 Self: Sized,
446 {
447 self.extend_one(item);
448 }
449}
450
451#[stable(feature = "extend_for_unit", since = "1.28.0")]
452impl Extend<()> for () {
453 fn extend<T: IntoIterator<Item = ()>>(&mut self, iter: T) {
454 iter.into_iter().for_each(drop)
455 }
456 fn extend_one(&mut self, _item: ()) {}
457}
458
459/// This trait is implemented for tuples up to twelve items long. The `impl`s for
460/// 1- and 3- through 12-ary tuples were stabilized after 2-tuples, in 1.85.0.
461#[doc(fake_variadic)] // the other implementations are below.
462#[stable(feature = "extend_for_tuple", since = "1.56.0")]
463impl<T, ExtendT> Extend<(T,)> for (ExtendT,)
464where
465 ExtendT: Extend<T>,
466{
467 /// Allows to `extend` a tuple of collections that also implement `Extend`.
468 ///
469 /// See also: [`Iterator::unzip`]
470 ///
471 /// # Examples
472 /// ```
473 /// // Example given for a 2-tuple, but 1- through 12-tuples are supported
474 /// let mut tuple = (vec![0], vec![1]);
475 /// tuple.extend([(2, 3), (4, 5), (6, 7)]);
476 /// assert_eq!(tuple.0, [0, 2, 4, 6]);
477 /// assert_eq!(tuple.1, [1, 3, 5, 7]);
478 ///
479 /// // also allows for arbitrarily nested tuples as elements
480 /// let mut nested_tuple = (vec![1], (vec![2], vec![3]));
481 /// nested_tuple.extend([(4, (5, 6)), (7, (8, 9))]);
482 ///
483 /// let (a, (b, c)) = nested_tuple;
484 /// assert_eq!(a, [1, 4, 7]);
485 /// assert_eq!(b, [2, 5, 8]);
486 /// assert_eq!(c, [3, 6, 9]);
487 /// ```
488 fn extend<I: IntoIterator<Item = (T,)>>(&mut self, iter: I) {
489 self.0.extend(iter.into_iter().map(|t| t.0));
490 }
491
492 fn extend_one(&mut self, item: (T,)) {
493 self.0.extend_one(item.0)
494 }
495
496 fn extend_reserve(&mut self, additional: usize) {
497 self.0.extend_reserve(additional)
498 }
499
500 unsafe fn extend_one_unchecked(&mut self, item: (T,)) {
501 // SAFETY: the caller guarantees all preconditions.
502 unsafe { self.0.extend_one_unchecked(item.0) }
503 }
504}
505
506/// This implementation turns an iterator of tuples into a tuple of types which implement
507/// [`Default`] and [`Extend`].
508///
509/// This is similar to [`Iterator::unzip`], but is also composable with other [`FromIterator`]
510/// implementations:
511///
512/// ```rust
513/// # fn main() -> Result<(), core::num::ParseIntError> {
514/// let string = "1,2,123,4";
515///
516/// // Example given for a 2-tuple, but 1- through 12-tuples are supported
517/// let (numbers, lengths): (Vec<_>, Vec<_>) = string
518/// .split(',')
519/// .map(|s| s.parse().map(|n: u32| (n, s.len())))
520/// .collect::<Result<_, _>>()?;
521///
522/// assert_eq!(numbers, [1, 2, 123, 4]);
523/// assert_eq!(lengths, [1, 1, 3, 1]);
524/// # Ok(()) }
525/// ```
526#[doc(fake_variadic)] // the other implementations are below.
527#[stable(feature = "from_iterator_for_tuple", since = "1.79.0")]
528impl<T, ExtendT> FromIterator<(T,)> for (ExtendT,)
529where
530 ExtendT: Default + Extend<T>,
531{
532 fn from_iter<Iter: IntoIterator<Item = (T,)>>(iter: Iter) -> Self {
533 let mut res = ExtendT::default();
534 res.extend(iter.into_iter().map(|t| t.0));
535 (res,)
536 }
537}
538
539/// An implementation of [`extend`](Extend::extend) that calls `extend_one` or
540/// `extend_one_unchecked` for each element of the iterator.
541fn default_extend<ExtendT, I, T>(collection: &mut ExtendT, iter: I)
542where
543 ExtendT: Extend<T>,
544 I: IntoIterator<Item = T>,
545{
546 // Specialize on `TrustedLen` and call `extend_one_unchecked` where
547 // applicable.
548 trait SpecExtend<I> {
549 fn extend(&mut self, iter: I);
550 }
551
552 // Extracting these to separate functions avoid monomorphising the closures
553 // for every iterator type.
554 fn extender<ExtendT, T>(collection: &mut ExtendT) -> impl FnMut(T) + use<'_, ExtendT, T>
555 where
556 ExtendT: Extend<T>,
557 {
558 move |item| collection.extend_one(item)
559 }
560
561 unsafe fn unchecked_extender<ExtendT, T>(
562 collection: &mut ExtendT,
563 ) -> impl FnMut(T) + use<'_, ExtendT, T>
564 where
565 ExtendT: Extend<T>,
566 {
567 // SAFETY: we make sure that there is enough space at the callsite of
568 // this function.
569 move |item| unsafe { collection.extend_one_unchecked(item) }
570 }
571
572 impl<ExtendT, I, T> SpecExtend<I> for ExtendT
573 where
574 ExtendT: Extend<T>,
575 I: Iterator<Item = T>,
576 {
577 default fn extend(&mut self, iter: I) {
578 let (lower_bound, _) = iter.size_hint();
579 if lower_bound > 0 {
580 self.extend_reserve(lower_bound);
581 }
582
583 iter.for_each(extender(self))
584 }
585 }
586
587 impl<ExtendT, I, T> SpecExtend<I> for ExtendT
588 where
589 ExtendT: Extend<T>,
590 I: TrustedLen<Item = T>,
591 {
592 fn extend(&mut self, iter: I) {
593 let (lower_bound, upper_bound) = iter.size_hint();
594 if lower_bound > 0 {
595 self.extend_reserve(lower_bound);
596 }
597
598 if upper_bound.is_none() {
599 // We cannot reserve more than `usize::MAX` items, and this is likely to go out of memory anyway.
600 iter.for_each(extender(self))
601 } else {
602 // SAFETY: We reserve enough space for the `size_hint`, and the iterator is
603 // `TrustedLen` so its `size_hint` is exact.
604 iter.for_each(unsafe { unchecked_extender(self) })
605 }
606 }
607 }
608
609 SpecExtend::extend(collection, iter.into_iter());
610}
611
612// Implements `Extend` and `FromIterator` for tuples with length larger than one.
613macro_rules! impl_extend_tuple {
614 ($(($ty:tt, $extend_ty:tt, $index:tt)),+) => {
615 #[doc(hidden)]
616 #[stable(feature = "extend_for_tuple", since = "1.56.0")]
617 impl<$($ty,)+ $($extend_ty,)+> Extend<($($ty,)+)> for ($($extend_ty,)+)
618 where
619 $($extend_ty: Extend<$ty>,)+
620 {
621 fn extend<T: IntoIterator<Item = ($($ty,)+)>>(&mut self, iter: T) {
622 default_extend(self, iter)
623 }
624
625 fn extend_one(&mut self, item: ($($ty,)+)) {
626 $(self.$index.extend_one(item.$index);)+
627 }
628
629 fn extend_reserve(&mut self, additional: usize) {
630 $(self.$index.extend_reserve(additional);)+
631 }
632
633 unsafe fn extend_one_unchecked(&mut self, item: ($($ty,)+)) {
634 // SAFETY: Those are our safety preconditions, and we correctly forward `extend_reserve`.
635 unsafe {
636 $(self.$index.extend_one_unchecked(item.$index);)+
637 }
638 }
639 }
640
641 #[doc(hidden)]
642 #[stable(feature = "from_iterator_for_tuple", since = "1.79.0")]
643 impl<$($ty,)+ $($extend_ty,)+> FromIterator<($($ty,)+)> for ($($extend_ty,)+)
644 where
645 $($extend_ty: Default + Extend<$ty>,)+
646 {
647 fn from_iter<Iter: IntoIterator<Item = ($($ty,)+)>>(iter: Iter) -> Self {
648 let mut res = Self::default();
649 res.extend(iter);
650 res
651 }
652 }
653 };
654}
655
656impl_extend_tuple!((A, ExA, 0), (B, ExB, 1));
657impl_extend_tuple!((A, ExA, 0), (B, ExB, 1), (C, ExC, 2));
658impl_extend_tuple!((A, ExA, 0), (B, ExB, 1), (C, ExC, 2), (D, ExD, 3));
659impl_extend_tuple!((A, ExA, 0), (B, ExB, 1), (C, ExC, 2), (D, ExD, 3), (E, ExE, 4));
660impl_extend_tuple!((A, ExA, 0), (B, ExB, 1), (C, ExC, 2), (D, ExD, 3), (E, ExE, 4), (F, ExF, 5));
661impl_extend_tuple!(
662 (A, ExA, 0),
663 (B, ExB, 1),
664 (C, ExC, 2),
665 (D, ExD, 3),
666 (E, ExE, 4),
667 (F, ExF, 5),
668 (G, ExG, 6)
669);
670impl_extend_tuple!(
671 (A, ExA, 0),
672 (B, ExB, 1),
673 (C, ExC, 2),
674 (D, ExD, 3),
675 (E, ExE, 4),
676 (F, ExF, 5),
677 (G, ExG, 6),
678 (H, ExH, 7)
679);
680impl_extend_tuple!(
681 (A, ExA, 0),
682 (B, ExB, 1),
683 (C, ExC, 2),
684 (D, ExD, 3),
685 (E, ExE, 4),
686 (F, ExF, 5),
687 (G, ExG, 6),
688 (H, ExH, 7),
689 (I, ExI, 8)
690);
691impl_extend_tuple!(
692 (A, ExA, 0),
693 (B, ExB, 1),
694 (C, ExC, 2),
695 (D, ExD, 3),
696 (E, ExE, 4),
697 (F, ExF, 5),
698 (G, ExG, 6),
699 (H, ExH, 7),
700 (I, ExI, 8),
701 (J, ExJ, 9)
702);
703impl_extend_tuple!(
704 (A, ExA, 0),
705 (B, ExB, 1),
706 (C, ExC, 2),
707 (D, ExD, 3),
708 (E, ExE, 4),
709 (F, ExF, 5),
710 (G, ExG, 6),
711 (H, ExH, 7),
712 (I, ExI, 8),
713 (J, ExJ, 9),
714 (K, ExK, 10)
715);
716impl_extend_tuple!(
717 (A, ExA, 0),
718 (B, ExB, 1),
719 (C, ExC, 2),
720 (D, ExD, 3),
721 (E, ExE, 4),
722 (F, ExF, 5),
723 (G, ExG, 6),
724 (H, ExH, 7),
725 (I, ExI, 8),
726 (J, ExJ, 9),
727 (K, ExK, 10),
728 (L, ExL, 11)
729);